home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / compiler / ast.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  62KB  |  1,836 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  5.  
  6. def flatten(seq):
  7.     l = []
  8.     for elt in seq:
  9.         t = type(elt)
  10.         if t is tuple or t is list:
  11.             for elt2 in flatten(elt):
  12.                 l.append(elt2)
  13.             
  14.         l.append(elt)
  15.     
  16.     return l
  17.  
  18.  
  19. def flatten_nodes(seq):
  20.     return _[1]
  21.  
  22. nodes = { }
  23.  
  24. class Node:
  25.     
  26.     def getChildren(self):
  27.         pass
  28.  
  29.     
  30.     def __iter__(self):
  31.         for n in self.getChildren():
  32.             yield n
  33.         
  34.  
  35.     
  36.     def asList(self):
  37.         return self.getChildren()
  38.  
  39.     
  40.     def getChildNodes(self):
  41.         pass
  42.  
  43.  
  44.  
  45. class EmptyNode(Node):
  46.     pass
  47.  
  48.  
  49. class Expression(Node):
  50.     nodes['expression'] = 'Expression'
  51.     
  52.     def __init__(self, node):
  53.         self.node = node
  54.  
  55.     
  56.     def getChildren(self):
  57.         return (self.node,)
  58.  
  59.     
  60.     def getChildNodes(self):
  61.         return (self.node,)
  62.  
  63.     
  64.     def __repr__(self):
  65.         return 'Expression(%s)' % repr(self.node)
  66.  
  67.  
  68.  
  69. class Add(Node):
  70.     
  71.     def __init__(self, .1, lineno = None):
  72.         (left, right) = .1
  73.         self.left = left
  74.         self.right = right
  75.         self.lineno = lineno
  76.  
  77.     
  78.     def getChildren(self):
  79.         return (self.left, self.right)
  80.  
  81.     
  82.     def getChildNodes(self):
  83.         return (self.left, self.right)
  84.  
  85.     
  86.     def __repr__(self):
  87.         return 'Add((%s, %s))' % (repr(self.left), repr(self.right))
  88.  
  89.  
  90.  
  91. class And(Node):
  92.     
  93.     def __init__(self, nodes, lineno = None):
  94.         self.nodes = nodes
  95.         self.lineno = lineno
  96.  
  97.     
  98.     def getChildren(self):
  99.         return tuple(flatten(self.nodes))
  100.  
  101.     
  102.     def getChildNodes(self):
  103.         nodelist = []
  104.         nodelist.extend(flatten_nodes(self.nodes))
  105.         return tuple(nodelist)
  106.  
  107.     
  108.     def __repr__(self):
  109.         return 'And(%s)' % (repr(self.nodes),)
  110.  
  111.  
  112.  
  113. class AssAttr(Node):
  114.     
  115.     def __init__(self, expr, attrname, flags, lineno = None):
  116.         self.expr = expr
  117.         self.attrname = attrname
  118.         self.flags = flags
  119.         self.lineno = lineno
  120.  
  121.     
  122.     def getChildren(self):
  123.         return (self.expr, self.attrname, self.flags)
  124.  
  125.     
  126.     def getChildNodes(self):
  127.         return (self.expr,)
  128.  
  129.     
  130.     def __repr__(self):
  131.         return 'AssAttr(%s, %s, %s)' % (repr(self.expr), repr(self.attrname), repr(self.flags))
  132.  
  133.  
  134.  
  135. class AssList(Node):
  136.     
  137.     def __init__(self, nodes, lineno = None):
  138.         self.nodes = nodes
  139.         self.lineno = lineno
  140.  
  141.     
  142.     def getChildren(self):
  143.         return tuple(flatten(self.nodes))
  144.  
  145.     
  146.     def getChildNodes(self):
  147.         nodelist = []
  148.         nodelist.extend(flatten_nodes(self.nodes))
  149.         return tuple(nodelist)
  150.  
  151.     
  152.     def __repr__(self):
  153.         return 'AssList(%s)' % (repr(self.nodes),)
  154.  
  155.  
  156.  
  157. class AssName(Node):
  158.     
  159.     def __init__(self, name, flags, lineno = None):
  160.         self.name = name
  161.         self.flags = flags
  162.         self.lineno = lineno
  163.  
  164.     
  165.     def getChildren(self):
  166.         return (self.name, self.flags)
  167.  
  168.     
  169.     def getChildNodes(self):
  170.         return ()
  171.  
  172.     
  173.     def __repr__(self):
  174.         return 'AssName(%s, %s)' % (repr(self.name), repr(self.flags))
  175.  
  176.  
  177.  
  178. class AssTuple(Node):
  179.     
  180.     def __init__(self, nodes, lineno = None):
  181.         self.nodes = nodes
  182.         self.lineno = lineno
  183.  
  184.     
  185.     def getChildren(self):
  186.         return tuple(flatten(self.nodes))
  187.  
  188.     
  189.     def getChildNodes(self):
  190.         nodelist = []
  191.         nodelist.extend(flatten_nodes(self.nodes))
  192.         return tuple(nodelist)
  193.  
  194.     
  195.     def __repr__(self):
  196.         return 'AssTuple(%s)' % (repr(self.nodes),)
  197.  
  198.  
  199.  
  200. class Assert(Node):
  201.     
  202.     def __init__(self, test, fail, lineno = None):
  203.         self.test = test
  204.         self.fail = fail
  205.         self.lineno = lineno
  206.  
  207.     
  208.     def getChildren(self):
  209.         children = []
  210.         children.append(self.test)
  211.         children.append(self.fail)
  212.         return tuple(children)
  213.  
  214.     
  215.     def getChildNodes(self):
  216.         nodelist = []
  217.         nodelist.append(self.test)
  218.         if self.fail is not None:
  219.             nodelist.append(self.fail)
  220.         
  221.         return tuple(nodelist)
  222.  
  223.     
  224.     def __repr__(self):
  225.         return 'Assert(%s, %s)' % (repr(self.test), repr(self.fail))
  226.  
  227.  
  228.  
  229. class Assign(Node):
  230.     
  231.     def __init__(self, nodes, expr, lineno = None):
  232.         self.nodes = nodes
  233.         self.expr = expr
  234.         self.lineno = lineno
  235.  
  236.     
  237.     def getChildren(self):
  238.         children = []
  239.         children.extend(flatten(self.nodes))
  240.         children.append(self.expr)
  241.         return tuple(children)
  242.  
  243.     
  244.     def getChildNodes(self):
  245.         nodelist = []
  246.         nodelist.extend(flatten_nodes(self.nodes))
  247.         nodelist.append(self.expr)
  248.         return tuple(nodelist)
  249.  
  250.     
  251.     def __repr__(self):
  252.         return 'Assign(%s, %s)' % (repr(self.nodes), repr(self.expr))
  253.  
  254.  
  255.  
  256. class AugAssign(Node):
  257.     
  258.     def __init__(self, node, op, expr, lineno = None):
  259.         self.node = node
  260.         self.op = op
  261.         self.expr = expr
  262.         self.lineno = lineno
  263.  
  264.     
  265.     def getChildren(self):
  266.         return (self.node, self.op, self.expr)
  267.  
  268.     
  269.     def getChildNodes(self):
  270.         return (self.node, self.expr)
  271.  
  272.     
  273.     def __repr__(self):
  274.         return 'AugAssign(%s, %s, %s)' % (repr(self.node), repr(self.op), repr(self.expr))
  275.  
  276.  
  277.  
  278. class Backquote(Node):
  279.     
  280.     def __init__(self, expr, lineno = None):
  281.         self.expr = expr
  282.         self.lineno = lineno
  283.  
  284.     
  285.     def getChildren(self):
  286.         return (self.expr,)
  287.  
  288.     
  289.     def getChildNodes(self):
  290.         return (self.expr,)
  291.  
  292.     
  293.     def __repr__(self):
  294.         return 'Backquote(%s)' % (repr(self.expr),)
  295.  
  296.  
  297.  
  298. class Bitand(Node):
  299.     
  300.     def __init__(self, nodes, lineno = None):
  301.         self.nodes = nodes
  302.         self.lineno = lineno
  303.  
  304.     
  305.     def getChildren(self):
  306.         return tuple(flatten(self.nodes))
  307.  
  308.     
  309.     def getChildNodes(self):
  310.         nodelist = []
  311.         nodelist.extend(flatten_nodes(self.nodes))
  312.         return tuple(nodelist)
  313.  
  314.     
  315.     def __repr__(self):
  316.         return 'Bitand(%s)' % (repr(self.nodes),)
  317.  
  318.  
  319.  
  320. class Bitor(Node):
  321.     
  322.     def __init__(self, nodes, lineno = None):
  323.         self.nodes = nodes
  324.         self.lineno = lineno
  325.  
  326.     
  327.     def getChildren(self):
  328.         return tuple(flatten(self.nodes))
  329.  
  330.     
  331.     def getChildNodes(self):
  332.         nodelist = []
  333.         nodelist.extend(flatten_nodes(self.nodes))
  334.         return tuple(nodelist)
  335.  
  336.     
  337.     def __repr__(self):
  338.         return 'Bitor(%s)' % (repr(self.nodes),)
  339.  
  340.  
  341.  
  342. class Bitxor(Node):
  343.     
  344.     def __init__(self, nodes, lineno = None):
  345.         self.nodes = nodes
  346.         self.lineno = lineno
  347.  
  348.     
  349.     def getChildren(self):
  350.         return tuple(flatten(self.nodes))
  351.  
  352.     
  353.     def getChildNodes(self):
  354.         nodelist = []
  355.         nodelist.extend(flatten_nodes(self.nodes))
  356.         return tuple(nodelist)
  357.  
  358.     
  359.     def __repr__(self):
  360.         return 'Bitxor(%s)' % (repr(self.nodes),)
  361.  
  362.  
  363.  
  364. class Break(Node):
  365.     
  366.     def __init__(self, lineno = None):
  367.         self.lineno = lineno
  368.  
  369.     
  370.     def getChildren(self):
  371.         return ()
  372.  
  373.     
  374.     def getChildNodes(self):
  375.         return ()
  376.  
  377.     
  378.     def __repr__(self):
  379.         return 'Break()'
  380.  
  381.  
  382.  
  383. class CallFunc(Node):
  384.     
  385.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno = None):
  386.         self.node = node
  387.         self.args = args
  388.         self.star_args = star_args
  389.         self.dstar_args = dstar_args
  390.         self.lineno = lineno
  391.  
  392.     
  393.     def getChildren(self):
  394.         children = []
  395.         children.append(self.node)
  396.         children.extend(flatten(self.args))
  397.         children.append(self.star_args)
  398.         children.append(self.dstar_args)
  399.         return tuple(children)
  400.  
  401.     
  402.     def getChildNodes(self):
  403.         nodelist = []
  404.         nodelist.append(self.node)
  405.         nodelist.extend(flatten_nodes(self.args))
  406.         if self.star_args is not None:
  407.             nodelist.append(self.star_args)
  408.         
  409.         if self.dstar_args is not None:
  410.             nodelist.append(self.dstar_args)
  411.         
  412.         return tuple(nodelist)
  413.  
  414.     
  415.     def __repr__(self):
  416.         return 'CallFunc(%s, %s, %s, %s)' % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  417.  
  418.  
  419.  
  420. class Class(Node):
  421.     
  422.     def __init__(self, name, bases, doc, code, lineno = None):
  423.         self.name = name
  424.         self.bases = bases
  425.         self.doc = doc
  426.         self.code = code
  427.         self.lineno = lineno
  428.  
  429.     
  430.     def getChildren(self):
  431.         children = []
  432.         children.append(self.name)
  433.         children.extend(flatten(self.bases))
  434.         children.append(self.doc)
  435.         children.append(self.code)
  436.         return tuple(children)
  437.  
  438.     
  439.     def getChildNodes(self):
  440.         nodelist = []
  441.         nodelist.extend(flatten_nodes(self.bases))
  442.         nodelist.append(self.code)
  443.         return tuple(nodelist)
  444.  
  445.     
  446.     def __repr__(self):
  447.         return 'Class(%s, %s, %s, %s)' % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
  448.  
  449.  
  450.  
  451. class Compare(Node):
  452.     
  453.     def __init__(self, expr, ops, lineno = None):
  454.         self.expr = expr
  455.         self.ops = ops
  456.         self.lineno = lineno
  457.  
  458.     
  459.     def getChildren(self):
  460.         children = []
  461.         children.append(self.expr)
  462.         children.extend(flatten(self.ops))
  463.         return tuple(children)
  464.  
  465.     
  466.     def getChildNodes(self):
  467.         nodelist = []
  468.         nodelist.append(self.expr)
  469.         nodelist.extend(flatten_nodes(self.ops))
  470.         return tuple(nodelist)
  471.  
  472.     
  473.     def __repr__(self):
  474.         return 'Compare(%s, %s)' % (repr(self.expr), repr(self.ops))
  475.  
  476.  
  477.  
  478. class Const(Node):
  479.     
  480.     def __init__(self, value, lineno = None):
  481.         self.value = value
  482.         self.lineno = lineno
  483.  
  484.     
  485.     def getChildren(self):
  486.         return (self.value,)
  487.  
  488.     
  489.     def getChildNodes(self):
  490.         return ()
  491.  
  492.     
  493.     def __repr__(self):
  494.         return 'Const(%s)' % (repr(self.value),)
  495.  
  496.  
  497.  
  498. class Continue(Node):
  499.     
  500.     def __init__(self, lineno = None):
  501.         self.lineno = lineno
  502.  
  503.     
  504.     def getChildren(self):
  505.         return ()
  506.  
  507.     
  508.     def getChildNodes(self):
  509.         return ()
  510.  
  511.     
  512.     def __repr__(self):
  513.         return 'Continue()'
  514.  
  515.  
  516.  
  517. class Decorators(Node):
  518.     
  519.     def __init__(self, nodes, lineno = None):
  520.         self.nodes = nodes
  521.         self.lineno = lineno
  522.  
  523.     
  524.     def getChildren(self):
  525.         return tuple(flatten(self.nodes))
  526.  
  527.     
  528.     def getChildNodes(self):
  529.         nodelist = []
  530.         nodelist.extend(flatten_nodes(self.nodes))
  531.         return tuple(nodelist)
  532.  
  533.     
  534.     def __repr__(self):
  535.         return 'Decorators(%s)' % (repr(self.nodes),)
  536.  
  537.  
  538.  
  539. class Dict(Node):
  540.     
  541.     def __init__(self, items, lineno = None):
  542.         self.items = items
  543.         self.lineno = lineno
  544.  
  545.     
  546.     def getChildren(self):
  547.         return tuple(flatten(self.items))
  548.  
  549.     
  550.     def getChildNodes(self):
  551.         nodelist = []
  552.         nodelist.extend(flatten_nodes(self.items))
  553.         return tuple(nodelist)
  554.  
  555.     
  556.     def __repr__(self):
  557.         return 'Dict(%s)' % (repr(self.items),)
  558.  
  559.  
  560.  
  561. class Discard(Node):
  562.     
  563.     def __init__(self, expr, lineno = None):
  564.         self.expr = expr
  565.         self.lineno = lineno
  566.  
  567.     
  568.     def getChildren(self):
  569.         return (self.expr,)
  570.  
  571.     
  572.     def getChildNodes(self):
  573.         return (self.expr,)
  574.  
  575.     
  576.     def __repr__(self):
  577.         return 'Discard(%s)' % (repr(self.expr),)
  578.  
  579.  
  580.  
  581. class Div(Node):
  582.     
  583.     def __init__(self, .1, lineno = None):
  584.         (left, right) = .1
  585.         self.left = left
  586.         self.right = right
  587.         self.lineno = lineno
  588.  
  589.     
  590.     def getChildren(self):
  591.         return (self.left, self.right)
  592.  
  593.     
  594.     def getChildNodes(self):
  595.         return (self.left, self.right)
  596.  
  597.     
  598.     def __repr__(self):
  599.         return 'Div((%s, %s))' % (repr(self.left), repr(self.right))
  600.  
  601.  
  602.  
  603. class Ellipsis(Node):
  604.     
  605.     def __init__(self, lineno = None):
  606.         self.lineno = lineno
  607.  
  608.     
  609.     def getChildren(self):
  610.         return ()
  611.  
  612.     
  613.     def getChildNodes(self):
  614.         return ()
  615.  
  616.     
  617.     def __repr__(self):
  618.         return 'Ellipsis()'
  619.  
  620.  
  621.  
  622. class Exec(Node):
  623.     
  624.     def __init__(self, expr, locals, globals, lineno = None):
  625.         self.expr = expr
  626.         self.locals = locals
  627.         self.globals = globals
  628.         self.lineno = lineno
  629.  
  630.     
  631.     def getChildren(self):
  632.         children = []
  633.         children.append(self.expr)
  634.         children.append(self.locals)
  635.         children.append(self.globals)
  636.         return tuple(children)
  637.  
  638.     
  639.     def getChildNodes(self):
  640.         nodelist = []
  641.         nodelist.append(self.expr)
  642.         if self.locals is not None:
  643.             nodelist.append(self.locals)
  644.         
  645.         if self.globals is not None:
  646.             nodelist.append(self.globals)
  647.         
  648.         return tuple(nodelist)
  649.  
  650.     
  651.     def __repr__(self):
  652.         return 'Exec(%s, %s, %s)' % (repr(self.expr), repr(self.locals), repr(self.globals))
  653.  
  654.  
  655.  
  656. class FloorDiv(Node):
  657.     
  658.     def __init__(self, .1, lineno = None):
  659.         (left, right) = .1
  660.         self.left = left
  661.         self.right = right
  662.         self.lineno = lineno
  663.  
  664.     
  665.     def getChildren(self):
  666.         return (self.left, self.right)
  667.  
  668.     
  669.     def getChildNodes(self):
  670.         return (self.left, self.right)
  671.  
  672.     
  673.     def __repr__(self):
  674.         return 'FloorDiv((%s, %s))' % (repr(self.left), repr(self.right))
  675.  
  676.  
  677.  
  678. class For(Node):
  679.     
  680.     def __init__(self, assign, list, body, else_, lineno = None):
  681.         self.assign = assign
  682.         self.list = list
  683.         self.body = body
  684.         self.else_ = else_
  685.         self.lineno = lineno
  686.  
  687.     
  688.     def getChildren(self):
  689.         children = []
  690.         children.append(self.assign)
  691.         children.append(self.list)
  692.         children.append(self.body)
  693.         children.append(self.else_)
  694.         return tuple(children)
  695.  
  696.     
  697.     def getChildNodes(self):
  698.         nodelist = []
  699.         nodelist.append(self.assign)
  700.         nodelist.append(self.list)
  701.         nodelist.append(self.body)
  702.         if self.else_ is not None:
  703.             nodelist.append(self.else_)
  704.         
  705.         return tuple(nodelist)
  706.  
  707.     
  708.     def __repr__(self):
  709.         return 'For(%s, %s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  710.  
  711.  
  712.  
  713. class From(Node):
  714.     
  715.     def __init__(self, modname, names, level, lineno = None):
  716.         self.modname = modname
  717.         self.names = names
  718.         self.level = level
  719.         self.lineno = lineno
  720.  
  721.     
  722.     def getChildren(self):
  723.         return (self.modname, self.names, self.level)
  724.  
  725.     
  726.     def getChildNodes(self):
  727.         return ()
  728.  
  729.     
  730.     def __repr__(self):
  731.         return 'From(%s, %s, %s)' % (repr(self.modname), repr(self.names), repr(self.level))
  732.  
  733.  
  734.  
  735. class Function(Node):
  736.     
  737.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno = None):
  738.         self.decorators = decorators
  739.         self.name = name
  740.         self.argnames = argnames
  741.         self.defaults = defaults
  742.         self.flags = flags
  743.         self.doc = doc
  744.         self.code = code
  745.         self.lineno = lineno
  746.         self.varargs = None
  747.         self.kwargs = None
  748.         if flags & CO_VARARGS:
  749.             self.varargs = 1
  750.         
  751.         if flags & CO_VARKEYWORDS:
  752.             self.kwargs = 1
  753.         
  754.  
  755.     
  756.     def getChildren(self):
  757.         children = []
  758.         children.append(self.decorators)
  759.         children.append(self.name)
  760.         children.append(self.argnames)
  761.         children.extend(flatten(self.defaults))
  762.         children.append(self.flags)
  763.         children.append(self.doc)
  764.         children.append(self.code)
  765.         return tuple(children)
  766.  
  767.     
  768.     def getChildNodes(self):
  769.         nodelist = []
  770.         if self.decorators is not None:
  771.             nodelist.append(self.decorators)
  772.         
  773.         nodelist.extend(flatten_nodes(self.defaults))
  774.         nodelist.append(self.code)
  775.         return tuple(nodelist)
  776.  
  777.     
  778.     def __repr__(self):
  779.         return 'Function(%s, %s, %s, %s, %s, %s, %s)' % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  780.  
  781.  
  782.  
  783. class GenExpr(Node):
  784.     
  785.     def __init__(self, code, lineno = None):
  786.         self.code = code
  787.         self.lineno = lineno
  788.         self.argnames = [
  789.             '.0']
  790.         self.varargs = None
  791.         self.kwargs = None
  792.  
  793.     
  794.     def getChildren(self):
  795.         return (self.code,)
  796.  
  797.     
  798.     def getChildNodes(self):
  799.         return (self.code,)
  800.  
  801.     
  802.     def __repr__(self):
  803.         return 'GenExpr(%s)' % (repr(self.code),)
  804.  
  805.  
  806.  
  807. class GenExprFor(Node):
  808.     
  809.     def __init__(self, assign, iter, ifs, lineno = None):
  810.         self.assign = assign
  811.         self.iter = iter
  812.         self.ifs = ifs
  813.         self.lineno = lineno
  814.         self.is_outmost = False
  815.  
  816.     
  817.     def getChildren(self):
  818.         children = []
  819.         children.append(self.assign)
  820.         children.append(self.iter)
  821.         children.extend(flatten(self.ifs))
  822.         return tuple(children)
  823.  
  824.     
  825.     def getChildNodes(self):
  826.         nodelist = []
  827.         nodelist.append(self.assign)
  828.         nodelist.append(self.iter)
  829.         nodelist.extend(flatten_nodes(self.ifs))
  830.         return tuple(nodelist)
  831.  
  832.     
  833.     def __repr__(self):
  834.         return 'GenExprFor(%s, %s, %s)' % (repr(self.assign), repr(self.iter), repr(self.ifs))
  835.  
  836.  
  837.  
  838. class GenExprIf(Node):
  839.     
  840.     def __init__(self, test, lineno = None):
  841.         self.test = test
  842.         self.lineno = lineno
  843.  
  844.     
  845.     def getChildren(self):
  846.         return (self.test,)
  847.  
  848.     
  849.     def getChildNodes(self):
  850.         return (self.test,)
  851.  
  852.     
  853.     def __repr__(self):
  854.         return 'GenExprIf(%s)' % (repr(self.test),)
  855.  
  856.  
  857.  
  858. class GenExprInner(Node):
  859.     
  860.     def __init__(self, expr, quals, lineno = None):
  861.         self.expr = expr
  862.         self.quals = quals
  863.         self.lineno = lineno
  864.  
  865.     
  866.     def getChildren(self):
  867.         children = []
  868.         children.append(self.expr)
  869.         children.extend(flatten(self.quals))
  870.         return tuple(children)
  871.  
  872.     
  873.     def getChildNodes(self):
  874.         nodelist = []
  875.         nodelist.append(self.expr)
  876.         nodelist.extend(flatten_nodes(self.quals))
  877.         return tuple(nodelist)
  878.  
  879.     
  880.     def __repr__(self):
  881.         return 'GenExprInner(%s, %s)' % (repr(self.expr), repr(self.quals))
  882.  
  883.  
  884.  
  885. class Getattr(Node):
  886.     
  887.     def __init__(self, expr, attrname, lineno = None):
  888.         self.expr = expr
  889.         self.attrname = attrname
  890.         self.lineno = lineno
  891.  
  892.     
  893.     def getChildren(self):
  894.         return (self.expr, self.attrname)
  895.  
  896.     
  897.     def getChildNodes(self):
  898.         return (self.expr,)
  899.  
  900.     
  901.     def __repr__(self):
  902.         return 'Getattr(%s, %s)' % (repr(self.expr), repr(self.attrname))
  903.  
  904.  
  905.  
  906. class Global(Node):
  907.     
  908.     def __init__(self, names, lineno = None):
  909.         self.names = names
  910.         self.lineno = lineno
  911.  
  912.     
  913.     def getChildren(self):
  914.         return (self.names,)
  915.  
  916.     
  917.     def getChildNodes(self):
  918.         return ()
  919.  
  920.     
  921.     def __repr__(self):
  922.         return 'Global(%s)' % (repr(self.names),)
  923.  
  924.  
  925.  
  926. class If(Node):
  927.     
  928.     def __init__(self, tests, else_, lineno = None):
  929.         self.tests = tests
  930.         self.else_ = else_
  931.         self.lineno = lineno
  932.  
  933.     
  934.     def getChildren(self):
  935.         children = []
  936.         children.extend(flatten(self.tests))
  937.         children.append(self.else_)
  938.         return tuple(children)
  939.  
  940.     
  941.     def getChildNodes(self):
  942.         nodelist = []
  943.         nodelist.extend(flatten_nodes(self.tests))
  944.         if self.else_ is not None:
  945.             nodelist.append(self.else_)
  946.         
  947.         return tuple(nodelist)
  948.  
  949.     
  950.     def __repr__(self):
  951.         return 'If(%s, %s)' % (repr(self.tests), repr(self.else_))
  952.  
  953.  
  954.  
  955. class IfExp(Node):
  956.     
  957.     def __init__(self, test, then, else_, lineno = None):
  958.         self.test = test
  959.         self.then = then
  960.         self.else_ = else_
  961.         self.lineno = lineno
  962.  
  963.     
  964.     def getChildren(self):
  965.         return (self.test, self.then, self.else_)
  966.  
  967.     
  968.     def getChildNodes(self):
  969.         return (self.test, self.then, self.else_)
  970.  
  971.     
  972.     def __repr__(self):
  973.         return 'IfExp(%s, %s, %s)' % (repr(self.test), repr(self.then), repr(self.else_))
  974.  
  975.  
  976.  
  977. class Import(Node):
  978.     
  979.     def __init__(self, names, lineno = None):
  980.         self.names = names
  981.         self.lineno = lineno
  982.  
  983.     
  984.     def getChildren(self):
  985.         return (self.names,)
  986.  
  987.     
  988.     def getChildNodes(self):
  989.         return ()
  990.  
  991.     
  992.     def __repr__(self):
  993.         return 'Import(%s)' % (repr(self.names),)
  994.  
  995.  
  996.  
  997. class Invert(Node):
  998.     
  999.     def __init__(self, expr, lineno = None):
  1000.         self.expr = expr
  1001.         self.lineno = lineno
  1002.  
  1003.     
  1004.     def getChildren(self):
  1005.         return (self.expr,)
  1006.  
  1007.     
  1008.     def getChildNodes(self):
  1009.         return (self.expr,)
  1010.  
  1011.     
  1012.     def __repr__(self):
  1013.         return 'Invert(%s)' % (repr(self.expr),)
  1014.  
  1015.  
  1016.  
  1017. class Keyword(Node):
  1018.     
  1019.     def __init__(self, name, expr, lineno = None):
  1020.         self.name = name
  1021.         self.expr = expr
  1022.         self.lineno = lineno
  1023.  
  1024.     
  1025.     def getChildren(self):
  1026.         return (self.name, self.expr)
  1027.  
  1028.     
  1029.     def getChildNodes(self):
  1030.         return (self.expr,)
  1031.  
  1032.     
  1033.     def __repr__(self):
  1034.         return 'Keyword(%s, %s)' % (repr(self.name), repr(self.expr))
  1035.  
  1036.  
  1037.  
  1038. class Lambda(Node):
  1039.     
  1040.     def __init__(self, argnames, defaults, flags, code, lineno = None):
  1041.         self.argnames = argnames
  1042.         self.defaults = defaults
  1043.         self.flags = flags
  1044.         self.code = code
  1045.         self.lineno = lineno
  1046.         self.varargs = None
  1047.         self.kwargs = None
  1048.         if flags & CO_VARARGS:
  1049.             self.varargs = 1
  1050.         
  1051.         if flags & CO_VARKEYWORDS:
  1052.             self.kwargs = 1
  1053.         
  1054.  
  1055.     
  1056.     def getChildren(self):
  1057.         children = []
  1058.         children.append(self.argnames)
  1059.         children.extend(flatten(self.defaults))
  1060.         children.append(self.flags)
  1061.         children.append(self.code)
  1062.         return tuple(children)
  1063.  
  1064.     
  1065.     def getChildNodes(self):
  1066.         nodelist = []
  1067.         nodelist.extend(flatten_nodes(self.defaults))
  1068.         nodelist.append(self.code)
  1069.         return tuple(nodelist)
  1070.  
  1071.     
  1072.     def __repr__(self):
  1073.         return 'Lambda(%s, %s, %s, %s)' % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  1074.  
  1075.  
  1076.  
  1077. class LeftShift(Node):
  1078.     
  1079.     def __init__(self, .1, lineno = None):
  1080.         (left, right) = .1
  1081.         self.left = left
  1082.         self.right = right
  1083.         self.lineno = lineno
  1084.  
  1085.     
  1086.     def getChildren(self):
  1087.         return (self.left, self.right)
  1088.  
  1089.     
  1090.     def getChildNodes(self):
  1091.         return (self.left, self.right)
  1092.  
  1093.     
  1094.     def __repr__(self):
  1095.         return 'LeftShift((%s, %s))' % (repr(self.left), repr(self.right))
  1096.  
  1097.  
  1098.  
  1099. class List(Node):
  1100.     
  1101.     def __init__(self, nodes, lineno = None):
  1102.         self.nodes = nodes
  1103.         self.lineno = lineno
  1104.  
  1105.     
  1106.     def getChildren(self):
  1107.         return tuple(flatten(self.nodes))
  1108.  
  1109.     
  1110.     def getChildNodes(self):
  1111.         nodelist = []
  1112.         nodelist.extend(flatten_nodes(self.nodes))
  1113.         return tuple(nodelist)
  1114.  
  1115.     
  1116.     def __repr__(self):
  1117.         return 'List(%s)' % (repr(self.nodes),)
  1118.  
  1119.  
  1120.  
  1121. class ListComp(Node):
  1122.     
  1123.     def __init__(self, expr, quals, lineno = None):
  1124.         self.expr = expr
  1125.         self.quals = quals
  1126.         self.lineno = lineno
  1127.  
  1128.     
  1129.     def getChildren(self):
  1130.         children = []
  1131.         children.append(self.expr)
  1132.         children.extend(flatten(self.quals))
  1133.         return tuple(children)
  1134.  
  1135.     
  1136.     def getChildNodes(self):
  1137.         nodelist = []
  1138.         nodelist.append(self.expr)
  1139.         nodelist.extend(flatten_nodes(self.quals))
  1140.         return tuple(nodelist)
  1141.  
  1142.     
  1143.     def __repr__(self):
  1144.         return 'ListComp(%s, %s)' % (repr(self.expr), repr(self.quals))
  1145.  
  1146.  
  1147.  
  1148. class ListCompFor(Node):
  1149.     
  1150.     def __init__(self, assign, list, ifs, lineno = None):
  1151.         self.assign = assign
  1152.         self.list = list
  1153.         self.ifs = ifs
  1154.         self.lineno = lineno
  1155.  
  1156.     
  1157.     def getChildren(self):
  1158.         children = []
  1159.         children.append(self.assign)
  1160.         children.append(self.list)
  1161.         children.extend(flatten(self.ifs))
  1162.         return tuple(children)
  1163.  
  1164.     
  1165.     def getChildNodes(self):
  1166.         nodelist = []
  1167.         nodelist.append(self.assign)
  1168.         nodelist.append(self.list)
  1169.         nodelist.extend(flatten_nodes(self.ifs))
  1170.         return tuple(nodelist)
  1171.  
  1172.     
  1173.     def __repr__(self):
  1174.         return 'ListCompFor(%s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.ifs))
  1175.  
  1176.  
  1177.  
  1178. class ListCompIf(Node):
  1179.     
  1180.     def __init__(self, test, lineno = None):
  1181.         self.test = test
  1182.         self.lineno = lineno
  1183.  
  1184.     
  1185.     def getChildren(self):
  1186.         return (self.test,)
  1187.  
  1188.     
  1189.     def getChildNodes(self):
  1190.         return (self.test,)
  1191.  
  1192.     
  1193.     def __repr__(self):
  1194.         return 'ListCompIf(%s)' % (repr(self.test),)
  1195.  
  1196.  
  1197.  
  1198. class Mod(Node):
  1199.     
  1200.     def __init__(self, .1, lineno = None):
  1201.         (left, right) = .1
  1202.         self.left = left
  1203.         self.right = right
  1204.         self.lineno = lineno
  1205.  
  1206.     
  1207.     def getChildren(self):
  1208.         return (self.left, self.right)
  1209.  
  1210.     
  1211.     def getChildNodes(self):
  1212.         return (self.left, self.right)
  1213.  
  1214.     
  1215.     def __repr__(self):
  1216.         return 'Mod((%s, %s))' % (repr(self.left), repr(self.right))
  1217.  
  1218.  
  1219.  
  1220. class Module(Node):
  1221.     
  1222.     def __init__(self, doc, node, lineno = None):
  1223.         self.doc = doc
  1224.         self.node = node
  1225.         self.lineno = lineno
  1226.  
  1227.     
  1228.     def getChildren(self):
  1229.         return (self.doc, self.node)
  1230.  
  1231.     
  1232.     def getChildNodes(self):
  1233.         return (self.node,)
  1234.  
  1235.     
  1236.     def __repr__(self):
  1237.         return 'Module(%s, %s)' % (repr(self.doc), repr(self.node))
  1238.  
  1239.  
  1240.  
  1241. class Mul(Node):
  1242.     
  1243.     def __init__(self, .1, lineno = None):
  1244.         (left, right) = .1
  1245.         self.left = left
  1246.         self.right = right
  1247.         self.lineno = lineno
  1248.  
  1249.     
  1250.     def getChildren(self):
  1251.         return (self.left, self.right)
  1252.  
  1253.     
  1254.     def getChildNodes(self):
  1255.         return (self.left, self.right)
  1256.  
  1257.     
  1258.     def __repr__(self):
  1259.         return 'Mul((%s, %s))' % (repr(self.left), repr(self.right))
  1260.  
  1261.  
  1262.  
  1263. class Name(Node):
  1264.     
  1265.     def __init__(self, name, lineno = None):
  1266.         self.name = name
  1267.         self.lineno = lineno
  1268.  
  1269.     
  1270.     def getChildren(self):
  1271.         return (self.name,)
  1272.  
  1273.     
  1274.     def getChildNodes(self):
  1275.         return ()
  1276.  
  1277.     
  1278.     def __repr__(self):
  1279.         return 'Name(%s)' % (repr(self.name),)
  1280.  
  1281.  
  1282.  
  1283. class Not(Node):
  1284.     
  1285.     def __init__(self, expr, lineno = None):
  1286.         self.expr = expr
  1287.         self.lineno = lineno
  1288.  
  1289.     
  1290.     def getChildren(self):
  1291.         return (self.expr,)
  1292.  
  1293.     
  1294.     def getChildNodes(self):
  1295.         return (self.expr,)
  1296.  
  1297.     
  1298.     def __repr__(self):
  1299.         return 'Not(%s)' % (repr(self.expr),)
  1300.  
  1301.  
  1302.  
  1303. class Or(Node):
  1304.     
  1305.     def __init__(self, nodes, lineno = None):
  1306.         self.nodes = nodes
  1307.         self.lineno = lineno
  1308.  
  1309.     
  1310.     def getChildren(self):
  1311.         return tuple(flatten(self.nodes))
  1312.  
  1313.     
  1314.     def getChildNodes(self):
  1315.         nodelist = []
  1316.         nodelist.extend(flatten_nodes(self.nodes))
  1317.         return tuple(nodelist)
  1318.  
  1319.     
  1320.     def __repr__(self):
  1321.         return 'Or(%s)' % (repr(self.nodes),)
  1322.  
  1323.  
  1324.  
  1325. class Pass(Node):
  1326.     
  1327.     def __init__(self, lineno = None):
  1328.         self.lineno = lineno
  1329.  
  1330.     
  1331.     def getChildren(self):
  1332.         return ()
  1333.  
  1334.     
  1335.     def getChildNodes(self):
  1336.         return ()
  1337.  
  1338.     
  1339.     def __repr__(self):
  1340.         return 'Pass()'
  1341.  
  1342.  
  1343.  
  1344. class Power(Node):
  1345.     
  1346.     def __init__(self, .1, lineno = None):
  1347.         (left, right) = .1
  1348.         self.left = left
  1349.         self.right = right
  1350.         self.lineno = lineno
  1351.  
  1352.     
  1353.     def getChildren(self):
  1354.         return (self.left, self.right)
  1355.  
  1356.     
  1357.     def getChildNodes(self):
  1358.         return (self.left, self.right)
  1359.  
  1360.     
  1361.     def __repr__(self):
  1362.         return 'Power((%s, %s))' % (repr(self.left), repr(self.right))
  1363.  
  1364.  
  1365.  
  1366. class Print(Node):
  1367.     
  1368.     def __init__(self, nodes, dest, lineno = None):
  1369.         self.nodes = nodes
  1370.         self.dest = dest
  1371.         self.lineno = lineno
  1372.  
  1373.     
  1374.     def getChildren(self):
  1375.         children = []
  1376.         children.extend(flatten(self.nodes))
  1377.         children.append(self.dest)
  1378.         return tuple(children)
  1379.  
  1380.     
  1381.     def getChildNodes(self):
  1382.         nodelist = []
  1383.         nodelist.extend(flatten_nodes(self.nodes))
  1384.         if self.dest is not None:
  1385.             nodelist.append(self.dest)
  1386.         
  1387.         return tuple(nodelist)
  1388.  
  1389.     
  1390.     def __repr__(self):
  1391.         return 'Print(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1392.  
  1393.  
  1394.  
  1395. class Printnl(Node):
  1396.     
  1397.     def __init__(self, nodes, dest, lineno = None):
  1398.         self.nodes = nodes
  1399.         self.dest = dest
  1400.         self.lineno = lineno
  1401.  
  1402.     
  1403.     def getChildren(self):
  1404.         children = []
  1405.         children.extend(flatten(self.nodes))
  1406.         children.append(self.dest)
  1407.         return tuple(children)
  1408.  
  1409.     
  1410.     def getChildNodes(self):
  1411.         nodelist = []
  1412.         nodelist.extend(flatten_nodes(self.nodes))
  1413.         if self.dest is not None:
  1414.             nodelist.append(self.dest)
  1415.         
  1416.         return tuple(nodelist)
  1417.  
  1418.     
  1419.     def __repr__(self):
  1420.         return 'Printnl(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1421.  
  1422.  
  1423.  
  1424. class Raise(Node):
  1425.     
  1426.     def __init__(self, expr1, expr2, expr3, lineno = None):
  1427.         self.expr1 = expr1
  1428.         self.expr2 = expr2
  1429.         self.expr3 = expr3
  1430.         self.lineno = lineno
  1431.  
  1432.     
  1433.     def getChildren(self):
  1434.         children = []
  1435.         children.append(self.expr1)
  1436.         children.append(self.expr2)
  1437.         children.append(self.expr3)
  1438.         return tuple(children)
  1439.  
  1440.     
  1441.     def getChildNodes(self):
  1442.         nodelist = []
  1443.         if self.expr1 is not None:
  1444.             nodelist.append(self.expr1)
  1445.         
  1446.         if self.expr2 is not None:
  1447.             nodelist.append(self.expr2)
  1448.         
  1449.         if self.expr3 is not None:
  1450.             nodelist.append(self.expr3)
  1451.         
  1452.         return tuple(nodelist)
  1453.  
  1454.     
  1455.     def __repr__(self):
  1456.         return 'Raise(%s, %s, %s)' % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1457.  
  1458.  
  1459.  
  1460. class Return(Node):
  1461.     
  1462.     def __init__(self, value, lineno = None):
  1463.         self.value = value
  1464.         self.lineno = lineno
  1465.  
  1466.     
  1467.     def getChildren(self):
  1468.         return (self.value,)
  1469.  
  1470.     
  1471.     def getChildNodes(self):
  1472.         return (self.value,)
  1473.  
  1474.     
  1475.     def __repr__(self):
  1476.         return 'Return(%s)' % (repr(self.value),)
  1477.  
  1478.  
  1479.  
  1480. class RightShift(Node):
  1481.     
  1482.     def __init__(self, .1, lineno = None):
  1483.         (left, right) = .1
  1484.         self.left = left
  1485.         self.right = right
  1486.         self.lineno = lineno
  1487.  
  1488.     
  1489.     def getChildren(self):
  1490.         return (self.left, self.right)
  1491.  
  1492.     
  1493.     def getChildNodes(self):
  1494.         return (self.left, self.right)
  1495.  
  1496.     
  1497.     def __repr__(self):
  1498.         return 'RightShift((%s, %s))' % (repr(self.left), repr(self.right))
  1499.  
  1500.  
  1501.  
  1502. class Slice(Node):
  1503.     
  1504.     def __init__(self, expr, flags, lower, upper, lineno = None):
  1505.         self.expr = expr
  1506.         self.flags = flags
  1507.         self.lower = lower
  1508.         self.upper = upper
  1509.         self.lineno = lineno
  1510.  
  1511.     
  1512.     def getChildren(self):
  1513.         children = []
  1514.         children.append(self.expr)
  1515.         children.append(self.flags)
  1516.         children.append(self.lower)
  1517.         children.append(self.upper)
  1518.         return tuple(children)
  1519.  
  1520.     
  1521.     def getChildNodes(self):
  1522.         nodelist = []
  1523.         nodelist.append(self.expr)
  1524.         if self.lower is not None:
  1525.             nodelist.append(self.lower)
  1526.         
  1527.         if self.upper is not None:
  1528.             nodelist.append(self.upper)
  1529.         
  1530.         return tuple(nodelist)
  1531.  
  1532.     
  1533.     def __repr__(self):
  1534.         return 'Slice(%s, %s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1535.  
  1536.  
  1537.  
  1538. class Sliceobj(Node):
  1539.     
  1540.     def __init__(self, nodes, lineno = None):
  1541.         self.nodes = nodes
  1542.         self.lineno = lineno
  1543.  
  1544.     
  1545.     def getChildren(self):
  1546.         return tuple(flatten(self.nodes))
  1547.  
  1548.     
  1549.     def getChildNodes(self):
  1550.         nodelist = []
  1551.         nodelist.extend(flatten_nodes(self.nodes))
  1552.         return tuple(nodelist)
  1553.  
  1554.     
  1555.     def __repr__(self):
  1556.         return 'Sliceobj(%s)' % (repr(self.nodes),)
  1557.  
  1558.  
  1559.  
  1560. class Stmt(Node):
  1561.     
  1562.     def __init__(self, nodes, lineno = None):
  1563.         self.nodes = nodes
  1564.         self.lineno = lineno
  1565.  
  1566.     
  1567.     def getChildren(self):
  1568.         return tuple(flatten(self.nodes))
  1569.  
  1570.     
  1571.     def getChildNodes(self):
  1572.         nodelist = []
  1573.         nodelist.extend(flatten_nodes(self.nodes))
  1574.         return tuple(nodelist)
  1575.  
  1576.     
  1577.     def __repr__(self):
  1578.         return 'Stmt(%s)' % (repr(self.nodes),)
  1579.  
  1580.  
  1581.  
  1582. class Sub(Node):
  1583.     
  1584.     def __init__(self, .1, lineno = None):
  1585.         (left, right) = .1
  1586.         self.left = left
  1587.         self.right = right
  1588.         self.lineno = lineno
  1589.  
  1590.     
  1591.     def getChildren(self):
  1592.         return (self.left, self.right)
  1593.  
  1594.     
  1595.     def getChildNodes(self):
  1596.         return (self.left, self.right)
  1597.  
  1598.     
  1599.     def __repr__(self):
  1600.         return 'Sub((%s, %s))' % (repr(self.left), repr(self.right))
  1601.  
  1602.  
  1603.  
  1604. class Subscript(Node):
  1605.     
  1606.     def __init__(self, expr, flags, subs, lineno = None):
  1607.         self.expr = expr
  1608.         self.flags = flags
  1609.         self.subs = subs
  1610.         self.lineno = lineno
  1611.  
  1612.     
  1613.     def getChildren(self):
  1614.         children = []
  1615.         children.append(self.expr)
  1616.         children.append(self.flags)
  1617.         children.extend(flatten(self.subs))
  1618.         return tuple(children)
  1619.  
  1620.     
  1621.     def getChildNodes(self):
  1622.         nodelist = []
  1623.         nodelist.append(self.expr)
  1624.         nodelist.extend(flatten_nodes(self.subs))
  1625.         return tuple(nodelist)
  1626.  
  1627.     
  1628.     def __repr__(self):
  1629.         return 'Subscript(%s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.subs))
  1630.  
  1631.  
  1632.  
  1633. class TryExcept(Node):
  1634.     
  1635.     def __init__(self, body, handlers, else_, lineno = None):
  1636.         self.body = body
  1637.         self.handlers = handlers
  1638.         self.else_ = else_
  1639.         self.lineno = lineno
  1640.  
  1641.     
  1642.     def getChildren(self):
  1643.         children = []
  1644.         children.append(self.body)
  1645.         children.extend(flatten(self.handlers))
  1646.         children.append(self.else_)
  1647.         return tuple(children)
  1648.  
  1649.     
  1650.     def getChildNodes(self):
  1651.         nodelist = []
  1652.         nodelist.append(self.body)
  1653.         nodelist.extend(flatten_nodes(self.handlers))
  1654.         if self.else_ is not None:
  1655.             nodelist.append(self.else_)
  1656.         
  1657.         return tuple(nodelist)
  1658.  
  1659.     
  1660.     def __repr__(self):
  1661.         return 'TryExcept(%s, %s, %s)' % (repr(self.body), repr(self.handlers), repr(self.else_))
  1662.  
  1663.  
  1664.  
  1665. class TryFinally(Node):
  1666.     
  1667.     def __init__(self, body, final, lineno = None):
  1668.         self.body = body
  1669.         self.final = final
  1670.         self.lineno = lineno
  1671.  
  1672.     
  1673.     def getChildren(self):
  1674.         return (self.body, self.final)
  1675.  
  1676.     
  1677.     def getChildNodes(self):
  1678.         return (self.body, self.final)
  1679.  
  1680.     
  1681.     def __repr__(self):
  1682.         return 'TryFinally(%s, %s)' % (repr(self.body), repr(self.final))
  1683.  
  1684.  
  1685.  
  1686. class Tuple(Node):
  1687.     
  1688.     def __init__(self, nodes, lineno = None):
  1689.         self.nodes = nodes
  1690.         self.lineno = lineno
  1691.  
  1692.     
  1693.     def getChildren(self):
  1694.         return tuple(flatten(self.nodes))
  1695.  
  1696.     
  1697.     def getChildNodes(self):
  1698.         nodelist = []
  1699.         nodelist.extend(flatten_nodes(self.nodes))
  1700.         return tuple(nodelist)
  1701.  
  1702.     
  1703.     def __repr__(self):
  1704.         return 'Tuple(%s)' % (repr(self.nodes),)
  1705.  
  1706.  
  1707.  
  1708. class UnaryAdd(Node):
  1709.     
  1710.     def __init__(self, expr, lineno = None):
  1711.         self.expr = expr
  1712.         self.lineno = lineno
  1713.  
  1714.     
  1715.     def getChildren(self):
  1716.         return (self.expr,)
  1717.  
  1718.     
  1719.     def getChildNodes(self):
  1720.         return (self.expr,)
  1721.  
  1722.     
  1723.     def __repr__(self):
  1724.         return 'UnaryAdd(%s)' % (repr(self.expr),)
  1725.  
  1726.  
  1727.  
  1728. class UnarySub(Node):
  1729.     
  1730.     def __init__(self, expr, lineno = None):
  1731.         self.expr = expr
  1732.         self.lineno = lineno
  1733.  
  1734.     
  1735.     def getChildren(self):
  1736.         return (self.expr,)
  1737.  
  1738.     
  1739.     def getChildNodes(self):
  1740.         return (self.expr,)
  1741.  
  1742.     
  1743.     def __repr__(self):
  1744.         return 'UnarySub(%s)' % (repr(self.expr),)
  1745.  
  1746.  
  1747.  
  1748. class While(Node):
  1749.     
  1750.     def __init__(self, test, body, else_, lineno = None):
  1751.         self.test = test
  1752.         self.body = body
  1753.         self.else_ = else_
  1754.         self.lineno = lineno
  1755.  
  1756.     
  1757.     def getChildren(self):
  1758.         children = []
  1759.         children.append(self.test)
  1760.         children.append(self.body)
  1761.         children.append(self.else_)
  1762.         return tuple(children)
  1763.  
  1764.     
  1765.     def getChildNodes(self):
  1766.         nodelist = []
  1767.         nodelist.append(self.test)
  1768.         nodelist.append(self.body)
  1769.         if self.else_ is not None:
  1770.             nodelist.append(self.else_)
  1771.         
  1772.         return tuple(nodelist)
  1773.  
  1774.     
  1775.     def __repr__(self):
  1776.         return 'While(%s, %s, %s)' % (repr(self.test), repr(self.body), repr(self.else_))
  1777.  
  1778.  
  1779.  
  1780. class With(Node):
  1781.     
  1782.     def __init__(self, expr, vars, body, lineno = None):
  1783.         self.expr = expr
  1784.         self.vars = vars
  1785.         self.body = body
  1786.         self.lineno = lineno
  1787.  
  1788.     
  1789.     def getChildren(self):
  1790.         children = []
  1791.         children.append(self.expr)
  1792.         children.append(self.vars)
  1793.         children.append(self.body)
  1794.         return tuple(children)
  1795.  
  1796.     
  1797.     def getChildNodes(self):
  1798.         nodelist = []
  1799.         nodelist.append(self.expr)
  1800.         if self.vars is not None:
  1801.             nodelist.append(self.vars)
  1802.         
  1803.         nodelist.append(self.body)
  1804.         return tuple(nodelist)
  1805.  
  1806.     
  1807.     def __repr__(self):
  1808.         return 'With(%s, %s, %s)' % (repr(self.expr), repr(self.vars), repr(self.body))
  1809.  
  1810.  
  1811.  
  1812. class Yield(Node):
  1813.     
  1814.     def __init__(self, value, lineno = None):
  1815.         self.value = value
  1816.         self.lineno = lineno
  1817.  
  1818.     
  1819.     def getChildren(self):
  1820.         return (self.value,)
  1821.  
  1822.     
  1823.     def getChildNodes(self):
  1824.         return (self.value,)
  1825.  
  1826.     
  1827.     def __repr__(self):
  1828.         return 'Yield(%s)' % (repr(self.value),)
  1829.  
  1830.  
  1831. for name, obj in globals().items():
  1832.     if isinstance(obj, type) and issubclass(obj, Node):
  1833.         nodes[name.lower()] = obj
  1834.         continue
  1835.  
  1836.